인덱싱

문자열에 부여된 인덱스를 통해서 개별 문자를 뽑아낼 수 있고, 이것을 인덱싱이라고 합니다. 비유하면, 여러분과 파이썬이 다음과 같은 대화를 한다고 생각하시면 됩니다.

You: “Hello world”의 0번 문자를 찾아줘!

Python: “Hello world”의 0번 문자는 “H” 입니다.

그렇다면 "Hello world"의 0번 문자를 찾아줘!’라는 명령을 어떻게 파이썬에 전달할 수 있을까요? 문자열 바로 뒤에 대괄호[]를 적고, 대괄호 안에 원하는 인덱스 숫자를 넣어주면 됩니다. 실제 파이썬 코드를 실행하면 다음과 같은 결과를 얻을 수 있습니다.

>>> "Hello world"[0]
'H'
>>> type("Hello world"[0]) # 문자열 인덱싱의 결과 > 문자열
<class 'str'>

>>> mystring = "Python is too slow"
>>> mystring[-2] != mystring[4]

>>> mystring = "Python is too slow"
>>> mystring[-2]
'o'
>>> mystring[4]
'o'
>>> mystring[-2] != mystring[4] # 두 값이 같지 않다: 거짓이므로 False 반환
False

슬라이싱

슬라이싱은 말 그대로 문자열의 일정 구간을 잘라내는 조작입니다. 일정 구간에 걸쳐서 인덱싱을 실행한다고 생각하시면 편합니다. 역시 대화로 표현하면 다음과 같습니다.

You: “Hello world”의 0번부터 4번까지의 문자를 찾아줘!

Python: “Hello world”의 0번부터 4번까지 문자는 “Hello” 입니다.

슬라이싱을 할 때는, [a:b]와 같이 대괄호 안에 구간을 입력해주면 됩니다. 구간을 입력할 때는 주의사항이 있습니다. 예시와 함께 보겠습니다.

>>> "Hello world"[0:4]
'Hell'

[0:4]의 구간을 입력했으므로 0, 1, 2, 3, 4번 문자가 출력되어야 할 것 같은데, 이상하게 'Hell'까지만 출력되었습니다. 이는 구간 [a:b]가 a는 포함하지만, b는 포함하지 않기 때문입니다. 즉 0번부터 4번까지를 슬라이싱 하려면 구간을 [0:5]와 같이 입력해야 합니다.

>>> "Hello world"[0:5]
'Hello'

슬라이싱의 구간 표현법을 정리하면 다음과 같습니다. 콜론 : 양쪽의 숫자를 생략하면 끝까지 슬라이싱합니다.

>>> mystring = "학회|데이터사이언스랩|yonseidslab.github.io|yonseidslab@naver.com"

>>> mystring = "학회|데이터사이언스랩|yonseidslab.github.io|yonseidslab@naver.com"
>>> len("yonseidslab@naver.com") # len 함수는 문자열의 길이를 반환합니다.
21
>>> mystring[-21:]
'yonseidslab@naver.com'

strip

strip 메소드는 문자열 양쪽의 공백을 모두 제거합니다. 원하는 문자열 뒤에 점을 찍어서 "문자열".strip()과 같이 적어주면 됩니다. 문자열 " Hello world "는 양쪽에 공백이 있고, 가운데에도 한 칸의 공백이 있습니다. strip 메소드를 활용하면 가운데의 띄어쓰기는 남겨두고 양 쪽의 공백만을 제거할 수 있습니다.

>>> s = "   Hello world   " # 문자열을 변수로 할당
>>> s.strip() # 양쪽의 공백 제거, 띄어쓰기는 남아있음
'Hello world'

사실 s.strip()은 s를 실제로 변화시키는 것이 아니라, 변화한 상태를 일시적으로 보여주는 것입니다. s를 출력해보면 양쪽의 공백이 그대로 남아있습니다. 공백을 제거한 결과를 s에 저장하고 싶다면, s = s.strip()과 같이 다시 할당을 해주어야 합니다. = 는 수학적인 의미의 등호가 아니라, 할당을 뜻하는 연산자이므로, s = s.strip()이라는 코드는 “s.strip()을 실행하고 이 결과를 s에 할당하라”는 의미입니다. s 와 s.strip() 이 같다는 의미가 아닙니다!

>>> s
'   Hello world   '
>>> s = s.strip() # s.strip()을 실행하고 이 결과를 s에 할당
>>> s   
'Hello world'

탭을 의미하는 \t 문자열과 개행을 의미하는 \n 문자열 역시 공백으로 인식됩니다. 아래 예시 코드를 보면, strip 메소드가 \t와 \n을 공백으로 인식하여 삭제하였음을 확인할 수 있습니다.

>>> s = "\n\n\nHello world\t\t\t"
>>> s.strip()
'Hello world'

replace

replace 메소드는 문자열 내의 특정 문자를 다른 문자로 모두 교체합니다. s.replace(a,b)와 같이 적어주면 s 문자열 내의 a 문자열을 모두 b 문자열로 교체합니다. 아래는 문자열 "You need Python" 에서 "Python"을 "R"로 바꾸어준 예제입니다. 역시 s.replace("Python","R")를 실행하는것만으로는 변수에 할당된 값이 변화하지 않습니다.

>>> s = 'You need Python' # 문자열을 변수 s에 할당
>>> s.replace("Python", "R") # s에서 Python -> R로 교체
'You need R'
>>> s # s는 변화하지 않음
'You need Python'
>>> s = s.replace("Python", "R") # Python을 R로 교체한 후 이 결과를 s에 할당
>>> s
'You need R'
>>> s = s.replace(" ", ",") # 모든 " "를 ","로 교체
>>> s
'You,need,R'

>>> a = "   C GO Java Python PHP   "
>>> b = "C|GO|Java|Python|PHP"

>>> a = "   C GO Java Python PHP   "
>>> b = "C|GO|Java|Python|PHP"
>>> tmp = a.strip()
>>> result = tmp.replace(" ","|")
>>> b == result
True

>>> a = "   C GO Java Python PHP   "
>>> b = "C|GO|Java|Python|PHP"
>>> result = a.strip().replace(" ","|")
>>> b == result
True

split

split 메소드는 특정 문자를 기준으로 문자열을 쪼개어 리스트를 반환합니다. s.split(a)와 같이 적어주면 a 문자열을 기준으로 s 문자열을 쪼개어 리스트를 반환합니다. 아무런 문자도 주어지지 않는다면 공백을 기준으로 문자열을 쪼갭니다.

>>> s = "Hello world"
>>> s.split(" ") # " " 를 기준으로 문자열을 쪼갬 > 이 결과를 리스트로 반환
['Hello', 'world']

>>> s = "one/two/three/four"
>>> s.split("/") # "/" 를 기준으로 문자열을 쪼갬 > 이 결과를 리스트로 반환
['one', 'two', 'three', 'four']

>>> a = "yonseidslab@gmail.com"
>>> a.replace("@",".").split(".")

>>> a = "yonseidslab@gmail.com"
>>> a.replace("@",".").split(".")
['yonseidslab', 'gmail', 'com']

join

join 메소드는 문자열 사이사이에 다른 문자를 삽입합니다. a.join(b)와 같이 적어주면 b 문자열 사이사이에 a 문자열을 삽입한니다. join 메소드는 문자열보다는 리스트에 대해 사용하는 경우가 많습니다

>>> alphabet = "ABCDEFG"
>>> "|".join(alphabet)
'A|B|C|D|E|F|G'

>>> mylist = ['a','b','c']
>>> ','.join(mylist)
'a,b,c'

함수의 구조

위키백과

우리가 흔히 알고 있는 함수는 y = f(x)와 같은 형태입니다. x라는 입력이 들어가면, f(x)라는 함수값이 출력됩니다. 파이썬의 함수 역시 이와 유사하게 작동합니다. 파이썬에서는 x를 인자(argument) 또는 매개변수(parameter)라고 부르고, y를 반환(return)이라고 부릅니다.

>>> def 함수명(매개변수1,매개변수2,...):
...    매개변수들을 활용한 계산 # 들여쓰기 필수!!!! 스페이스 네 개 !!!!
...    return 결과물

파이썬의 함수는 def 문을 통해 만들 수 있으며, def 문의 구조를 일반화하면 위와 같습니다. def 다음 함수명을 적고, 괄호 안에 필요한 매개변수들을 적어줍니다. 이후 다음 줄로 넘어가 들여쓰기(스페이스 네 개)된 상태에서 계산을 진행하면 됩니다. 대부분의 편집기에서는 자동으로 들여쓰기를 적용해줍니다. 계산이 끝나면 return 절에 반환할 결과물을 적어줍니다.

>>> def add(x,y): # def 함수이름(매개변수1, 매개변수2):
...     result = x + y 
...     return result # return 결과물
>>> add(x=4,y=5)
9
>>> add(4,5)
9

add 함수는 x와 y라는 두 개의 인자를 받아서 더하고, 이 결과를 반환합니다. 함수를 사용할 때는 함수 이름을 적고, 등호 =를 사용해서 필요한 인자들을 전달해줍니다. 인자를 순서대로 전달했다면, 매개변수명을 생략할 수 있습니다.

함수 안에서 사용되는 변수들은 지역 변수(local variable)로, 함수 안에서만 유효합니다. 즉 함수 밖에서는 함수 안의 변수들에 접근할 수 없습니다. 예를 들어 우리가 만든 add 함수에 x=4, y=5를 전달하고 실행하면 함수 안에서는 다음과 같은 일이 일어날 것입니다.

...    result = 4 + 5
...    return result

하지만 함수를 실행한 후 result를 출력하면 변수 result가 선언되지 않았다는 에러가 발생합니다. 함수 안에서 사용되는 변수는 지역 변수(local variables)로, 함수 안에서만 유효하기 때문입니다. 따라서 함수의 실행 결과를 저장하려면 이를 별도의 변수에 할당해주어야 합니다.

>>> add(x=4,y=5)
9
>>> print(result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'result' is not defined
>>> a = add(4,5) # 인자를 순서대로 전달할 때에는 매개변수명을 생략할 수 있습니다
>>> print(a)
9

>>> my_function("yonseidslab@gmail.com")
True
>>> my_function("yonseidslab@naver.com")
False

>>> def my_function(address):
...     result = "@gmail.com" in address # in 연산: @gmail.com 포함하면 True, 아니면 False
...     return result
>>> my_function(address="yonseidslab@gmail.com")
True
>>> my_function("yonseidslab@naver.com") # 인자를 순서대로 전달할 경우에는 매개변수 생략 가능
False

>>> def my_function(address):
...     return "@gmail.com" in address

인자와 반환

사실 파이썬의 함수는 일반적인 함수와 달리 x와 y가 없이도 작동할 수 있습니다. 즉 파이썬의 함수는 다음과 같은 네 가지 경우로 구분할 수 있습니다.

1. 매개변수와 반환이 모두 있는 함수
2. 매개변수가 없고 반환이 있는 함수
3. 매개변수가 있고 반환이 없는 함수
4. 매개변수와 반환이 모두 없는 함수

>>> def my_function(x,y):
...     print(x+y)
>>> def my_function2():
...     print("Hello world")
>>> def my_function3():
...     return("Hello world")
>>> def my_function4(x,y):
...     return("Hello world")

lambda 함수

지금까지는 def 문을 통해서 함수를 만드는 방법을 배웠습니다. 하지만 한 줄 정도의 간단한 함수를 만들 때는 lambda 문을 사용하는 것이 편리합니다. lambda 뒤에 괄호를 사용하지 않고 매개변수들을 나열해준 후, 콜론 다음에 계산식을 적어주면 됩니다. lambda 문에서는 return을 사용하지 않으며, 콜론 이후 코드의 실행 결과가 즉시 반환됩니다. lambda 문을 변수에 할당하면 해당 변수명으로 함수가 생성됩니다.

>>> add = lambda x,y: x+y
>>> add(4,5)
9

lambda 문의 구조를 일반화하면 다음과 같습니다.

>>> 함수명 = lambda 매개변수1, 매개변수2, ...: 계산식

인덱싱

문자열의 인덱싱과 슬라이싱에 익숙해졌다면, 리스트의 인덱싱과 슬라이싱 역시 어렵지 않을 겁니다. 리스트의 인덱싱 역시 문자열과 마찬가지로 대괄호 []를 사용합니다.

>>> [0.25, 0.5, 0.75, 1.0][1]
0.5
>>> ["You", "need", "Python"][-1]
'Python'
>>> [[1,2,3],[4,5,6],[7,8,9],[10,11,12]][2]
[7, 8, 9]

인덱싱을 사용하여 개별 요소를 추출하였다면, 해당 요소에 대해 다시 조작을 가하는 것도 가능합니다. 아래는 리스트에서 개별 요소를 추출한 후, 해당 요소에 대해 다시 인덱싱/슬라이싱을 적용한 예제입니다.

>>> mylist = ["Life", "is", "short", "you", "need", "Python"] # 리스트 생성
>>> element = mylist[0] # 0번 요소인 "Life" 추출
>>> element[:2] # "Life"에서 2번 문자까지 슬라이싱
'Li'
>>> element[:2] == mylist[0][:2] # 위 과정을 붙여서 쓴 코드
True

>>> WhereIsWally = [["wally","Willy Wonka"],[["waly"],"Wally","Wallmart"]]

>>> WhereIsWally = [["wally","Willy Wonka"],[["waly"],"Wally","Wallmart"]]
>>> WhereIsWally[1][1]
'Wally'

>>> address = "서울특별시 서대문구 신촌동 연세로 50"

>>> address = "서울특별시 서대문구 신촌동 연세로 50"
>>> address.split(" ")[2]
'신촌동'

슬라이싱

리스트 슬라이싱 역시 문자열 슬라이싱과 다르지 않습니다. 대괄호 안에 콜론을 써서 구간을 표현해주시면 됩니다.

>>> ['one', 'two', 'three', 'four', 'five'][:2]
['one', 'two']
>>> ["Apple","Banana", "Computer", "Data"][1:3]
['Banana', 'Computer']
>>> [1, 2, 3, 4, 5][3:-1]
[4]

이번에는 특정 요소들을 건너뛰는 슬라이싱을 배워보겠습니다. 예를 들어 리스트 안에서 홀수 인덱스를 가진 요소들만 추출할고 싶을 때, 이 방법을 활용할 수 있습니다. 기본적인 구간 표현법은 start:end:step과 같습니다. 이는 start부터 end까지 step만큼 이동하면서 가져오라는 의미입니다. step이 1이면 바로 다음 요소로 가는 것이므로 해당 구간의 모든 요소들을 가져올 것이고, step이 2이면 한 칸씩 건너뛰면서 요소들을 가져올 것입니다.

예제와 함께 보겠습니다. 첫 예제에서 사용한 구간 1:8:2는 1번 인덱스부터 8번 인덱스까지 2칸씩 진행하면서 요소들을 가져오라는 뜻입니다. 즉 따라서 1, 3, 5, 7번 인덱스에 해당하는 1, 3, 5, 7이 추출되었습니다. 두 번째 예제에서는 start와 end를 생략하여 리스트의 전 구간을 표현하였고, step은 2로 주었습니다. 따라서 0, 2, 4, 6, 8번 인덱스에 해당하는 0, 2, 4, 6, 8이 추출되었습니다.

>>> [0, 1, 2, 3, 4, 5, 6, 7, 8][1:8:2]
[1, 3, 5, 7]
>> [0, 1, 2, 3, 4, 5, 6, 7, 8][::2]
[0, 2, 4, 6, 8]

append

append 메소드는 특정 리스트에 요소를 추가하는 메소드입니다. 이 메소드는 리스트를 즉시 변형시키므로 주의해서 사용해야 합니다. 즉 a.append(b)를 실행하면 즉시 리스트에 요소가 추가되고, 다시 할당을 할 필요가 없습니다.

>>> a = [1,2,3]
>>> a.append(4)
>>> a
[1,2,3,4]

index

>>> a = ["A","B","C"]
>>> a.index("C")
2

합집합

합집합은 | 연산자 혹은 union 메소드를 활용합니다. 집합의 개수와 상관 없이 연산이 가능합니다.

>>> a = set([1,2,3])
>>> b = set([3,4,5])
>>> c = set([5,6,7])
>>> a | b
{3}
>>> a.union(b)
>>> a | b | c
{1, 2, 3, 4, 5, 6, 7}
>>> a.union(b,c)
{1, 2, 3, 4, 5, 6, 7}

교집합

교집합은 & 연산자 혹은 intersection 메소드를 활용합니다. 역시 집합의 개수와 상관 없이 연산이 가능합니다.

>>> a & b
{3}
>>> a.intersection(b)
{3}
>>> a.intersection(b,c)
set()

차집합

차집합은 - 연산자 혹은 difference 메소드를 활용합니다.

>>> a - b
{1, 2}
>>> a.difference(b)
{1, 2}
>>> b.difference(a,c)
{4}